home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 626-637 / disk_633 / galer / source / gal.c next >
C/C++ Source or Header  |  1992-05-06  |  8KB  |  350 lines
  1. /****************************************************************/
  2. /*                                */
  3. /* GAL.c - enthält Routinen zum Beschreiben und zum Lesen    */
  4. /* von GALs                            */
  5. /*                                */
  6. /* compilieren: cc GAL.c                    */
  7. /*                                */
  8. /****************************************************************/
  9.  
  10.  
  11.  
  12. #include "exec/types.h"
  13. #include <ctype.h>
  14.  
  15. #include "GALer.h"
  16.  
  17.  
  18. extern    UBYTE    GadgetSBuff[60];
  19. extern    int    GALType;
  20. extern    struct    JedecStruct    Jedec;
  21.  
  22.  
  23. int    MaxFuseAdr, SigAdr;
  24.  
  25.  
  26. UBYTE    SignatureTxt[] = {"Signatur: $00 $00 $00 $00 $00 $00 $00 $00  :  XXXXXXXX"};
  27. UBYTE    PTTxt[]        = {"PT: 0000000000000000000000000000000000000000000000000000000000000000"};
  28. UBYTE    ConTxt[]       = {"XOR(n): 00000000    SYN: 0    AC0: 0"};
  29. UBYTE    AC1Txt[]       = {"AC1(n): 00000000"};
  30.  
  31.  
  32. /*ProgramGAL
  33.   liest Jedec-Datei ein, testet das GAL auf Programmierbarkeit und
  34.   programmiert es anschließend entsprechend der Jedec-Datei
  35.   Aufruf: ProgramGAL();
  36. */
  37. ProgramGAL()
  38. {
  39.  if (MyRequest(LOAD_REQ,(UBYTE *)"Bitte Namen des Jedec-Files eingeben")) {
  40.    if (!(GetJedec(&GadgetSBuff))) {
  41.      if (MyRequest(ASK_REQ,(UBYTE *)"Bitte GAL einsetzen")) {
  42.         ProgJedecToGAL();
  43.         MyRequest(INFO_REQ,(UBYTE *)"GAL wurde programmiert");
  44.       }
  45.     }
  46.   }
  47. }
  48.  
  49.  
  50. /* GAL kopieren
  51. */
  52. CopyGAL()
  53. {
  54.  if (MyRequest(ASK_REQ,(UBYTE *)"Bitte Original-GAL einsetzen")) {
  55.    ReadGALToJedec();
  56.    if (MyRequest(ASK_REQ,(UBYTE *)"Bitte Ziel-GAL einsetzen")) {
  57.      ProgJedecToGAL();
  58.      MyRequest(INFO_REQ,(UBYTE *)"GAL wurde kopiert");
  59.     }
  60.   }
  61. }
  62.  
  63.  
  64.  
  65. /* überprüfe, ob GAL leer ist*/
  66. Leertest()
  67. {
  68.  if (MyRequest(ASK_REQ,(UBYTE *)"Bitte GAL zum Leertest einsetzen")) {
  69.    if (CheckGAL())
  70.      MyRequest(INFO_REQ,(UBYTE *)"GAL ist leer");
  71.    else
  72.      MyRequest(INFO_REQ,(UBYTE *)"GAL ist NICHT leer");
  73.   }
  74. }
  75.  
  76.  
  77.  
  78. /* CheckGAL
  79.    teste ob GAL leer ist
  80.    Aufruf:   return=CheckGAL();
  81.    Ergebnis: return: 1=GAL ist leer; 0=GAL ist nicht leer
  82. */
  83. CheckGAL()
  84. {
  85. int n;
  86.  ReadGALToJedec();
  87.  for (n=0; n<sizeof(Jedec); n++) {
  88.    if (((GALType == GAL16V8) && ((n < LOGIC16_SIZE) || (n >= LOGIC20_SIZE))) || (GALType == GAL20V8)) {
  89.      if (!Jedec.GALLogic[n])
  90.        return(0);
  91.     }
  92.   }
  93.  return(1);
  94. }
  95.  
  96.  
  97.  
  98. /****************************************************************/
  99. /* Die nachfolgenden Routinen greifen direkt über das Modul    */
  100. /* "port.asm" auf das GAL zu.                    */
  101. /****************************************************************/
  102.  
  103. /* PrintACW
  104.    gibt das Architecture Control Word aus
  105.    Aufruf: PrintACW
  106. */
  107. PrintACW()
  108. {
  109. BYTE    bit;
  110. int    n, acw_num, xor_num, ac1_num ;
  111.  
  112.  acw_num = xor_num = ac1_num =0;
  113.  
  114.  if (MyRequest(ASK_REQ,(UBYTE *)"ACW lesen?")) {
  115.    LED(ON);                    /*LED anschalten*/
  116.    EditMode(VERIFY);                /*GAL in Edit-Mode versetzen*/
  117.    SetRow(ACW_ADR);                /*ACW adressieren*/
  118.    STRImpuls();                    /*ACW in's Schiebereg. holen*/
  119.    for (n=0; n<ACW_SIZE; n++) {            /*ACW einlesen*/
  120.       bit=(BYTE)SDOut();
  121.       Clock();
  122.  
  123.       if (n<32) {                /*ACW0-31 eintragen*/
  124.         PTTxt[4+acw_num]=bit+'0';
  125.     acw_num++;
  126.        }
  127.       if (n>=50) {                /*ACW32-63 eintragen*/
  128.         PTTxt[4+acw_num]=bit+'0';
  129.     acw_num++;
  130.        }
  131.       if (n==36)                 /*AC0-Bit*/
  132.         ConTxt[35]=bit+'0';
  133.       if (n==45)                 /*SYN-Bit*/
  134.         ConTxt[25]=bit+'0';
  135.       if ((n>=32)&&(n<=35)) {             /*4 XOR-Bits*/
  136.         ConTxt[8+xor_num]=bit+'0';
  137.         xor_num++;
  138.        }
  139.       if ((n>=46)&&(n<=49)) {             /*4 XOR-Bits*/
  140.         ConTxt[8+xor_num]=bit+'0';
  141.         xor_num++;
  142.        }
  143.       if ((n>=37)&&(n<=44)) {            /*AC1-Bits*/
  144.     AC1Txt[8+ac1_num]=bit+'0';
  145.     ac1_num++;
  146.        }
  147.      }
  148.    InitGALer();
  149.    EnableOutput();
  150.  
  151.    PrintText(&PTTxt);
  152.    PrintText(&ConTxt);
  153.    PrintText(&AC1Txt);
  154.   }
  155. }
  156.  
  157.  
  158.  
  159. /* PrintSignature
  160.    gibt Signatur im Textfeld aus
  161.    Aufruf: PrintSignature();
  162. */
  163. PrintSignature()
  164. {
  165. UBYTE    strn[4];
  166. BYTE    byte, bit;
  167. int    n;
  168.  
  169.  if (MyRequest(ASK_REQ,(UBYTE *)"Signatur lesen?")) {
  170.    LED(ON);                    /*LED anschalten*/
  171.    EditMode(VERIFY);                /*GAL in Edit-Mode versetzen*/
  172.    SetRow(SigAdr);                /*Signatur adressieren*/
  173.    STRImpuls();                    /*Signatur in's Schiebereg. holen*/
  174.                          /*Signatur einlesen*/
  175.    for (n=0; n<SIG_SIZE; n++) {
  176.      bit=(BYTE)SDOut();                /*Bit holen und 8 Bits*/
  177.      byte|=bit;                    /*zu einem Byte zusammenfügen*/
  178.      if (!((n+1)%8)) {                /*Text erstellen*/
  179.        sprintf(&strn,"%02x",(int)byte);
  180.        strncpy(&SignatureTxt[11+4*((n+1)/8-1)],&strn,2);
  181.        if (isprint(byte))
  182.          SignatureTxt[46+((n+1)/8-1)]=byte;
  183.        else
  184.          SignatureTxt[46+((n+1)/8-1)]='.';
  185.       }
  186.      byte<<=1;
  187.      Clock();
  188.     } 
  189.    InitGALer();
  190.    EnableOutput();
  191.  
  192.    PrintText(&SignatureTxt);
  193.   }
  194. }
  195.  
  196.  
  197.  
  198.  
  199. /* ProgJedecToGAL
  200.    schreibt die Jedec-Struktur in das GAL
  201.    (eigentliche Programmier-Routine)
  202. */
  203. ProgJedecToGAL()
  204. {
  205. int    n, row, bit;
  206.  
  207.  
  208.  LED(ON);
  209.  EditMode(PROG);
  210.  
  211.  for (row=0; row<=MaxFuseAdr; row++) {         /*Logik-Matrix schreiben*/
  212.     SetRow(row);
  213.     for (n=0; n<ROW_SIZE; n++) {
  214.        SDIn((int)Jedec.GALLogic[row+(MaxFuseAdr+1)*n]); /*Bit an SDIn-Eingang anlegen*/
  215.        Clock();        /*Bit in Schieberegister takten*/
  216.       }
  217.     STRImpuls();                /*Row (64 Bit) programmieren*/
  218.    }
  219.  
  220.  SetRow(SigAdr);                 /*Signatur schreiben*/
  221.  for (n=0; n<SIG_SIZE; n++) {
  222.     SDIn((int)Jedec.GALSig[n]);            /*Bit an SDIn-Eingang anlegen*/
  223.     Clock();            /*Bit in Schieberegister takten*/
  224.    }
  225.  STRImpuls();                    /*Daten programmieren*/
  226.  
  227.  
  228.  SetRow(ACW_ADR);                /*ACW schreiben*/
  229.  for (n=0; n<ACW_SIZE; n++) {
  230.     if (n<=31)
  231.       bit=Jedec.GALPT[n];
  232.     if ((n>=32)&&(n<=35))             /*4 XOR-Bits*/
  233.       bit=Jedec.GALXOR[n-32];
  234.     if (n==36)                    /*AC0-Bit*/
  235.       bit=Jedec.GALAC0;
  236.     if ((n>=37)&&(n<=44))             /*AC1-Bits*/
  237.       bit=Jedec.GALAC1[n-37];
  238.     if (n==45)                     /*SYN-Bit*/
  239.       bit=Jedec.GALSYN;
  240.     if ((n>=46)&&(n<=49))             /*4 XOR-Bits*/
  241.       bit=Jedec.GALXOR[n-42];
  242.     if ((n>=50)&&(n<=81))             /*PT32-PT63*/
  243.       bit=Jedec.GALPT[n-18];
  244.     SDIn((int)bit);                /*Bit an SDIn-Eingang anlegen*/
  245.     Clock();            /*Bit in Schieberegister takten*/
  246.    }
  247.  
  248.  STRImpuls();                /*Daten programmieren*/
  249.  
  250.  InitGALer();
  251.  EnableOutput();
  252. }
  253.  
  254.  
  255. /* ReadGALToJedec
  256.    liest das GAL in die Jedec-Struktur
  257.    (MaxFuseAdr und SigAdr müssen initialisiert sein)
  258.    Aufruf:   ReadGALToJedec()
  259. */
  260. ReadGALToJedec()
  261. {
  262. int    n, row;
  263. BYTE    bit;
  264.  
  265.  
  266.  LED(ON);
  267.  EditMode(VERIFY);                /*GAL in Verify-Mode*/
  268.  
  269.  for (row=0; row<=MaxFuseAdr; row++) {        /*Logik-Matrix lesen*/
  270.     SetRow(row);                /*Adresse anlegen*/
  271.     STRImpuls();                /*Bits in's Schieberegister holen*/
  272.     for (n=0; n<ROW_SIZE; n++) {        /*seriell auslesen*/
  273.        Jedec.GALLogic[row+(MaxFuseAdr+1)*n]=(BYTE)SDOut();    /*SDOut-Ausgang lesen*/
  274.        Clock();                    /*nächstes Bit an SDOut holen*/
  275.       }
  276.    }
  277.  
  278.  
  279.  SetRow(SigAdr);                 /*Signatur auslesesn*/
  280.  STRImpuls();
  281.  for (n=0; n<SIG_SIZE; n++) {
  282.     Jedec.GALSig[n]=(BYTE)SDOut();
  283.     Clock();
  284.    }
  285.  
  286.  
  287.  SetRow(ACW_ADR);                /*Architecture Control Word holen*/
  288.  STRImpuls();                    /*Bits in's Schieberegister*/
  289.  for (n=0; n<ACW_SIZE; n++) {
  290.     bit=(BYTE)SDOut();
  291.     Clock();
  292.     if (n<=31)
  293.       Jedec.GALPT[n]=bit;
  294.     if ((n>=32)&&(n<=35))             /*4 XOR-Bits*/
  295.       Jedec.GALXOR[n-32]=bit;
  296.     if (n==36)                    /*AC0-Bit*/
  297.       Jedec.GALAC0=bit;
  298.     if ((n>=37)&&(n<=44))             /*AC1-Bits*/
  299.       Jedec.GALAC1[n-37]=bit;
  300.     if (n==45)                     /*SYN-Bit*/
  301.       Jedec.GALSYN=bit;
  302.     if ((n>=46)&&(n<=49))             /*4 XOR-Bits*/
  303.       Jedec.GALXOR[n-42]=bit;
  304.     if ((n>=50)&&(n<=81))             /*PT32-PT63*/
  305.       Jedec.GALPT[n-18]=bit;
  306.    }
  307.  
  308.  InitGALer();                    /*alle Ausgänge auf LOW*/
  309.  EnableOutput();
  310. }
  311.  
  312.  
  313.  
  314. /* Sicherungsbit setzen*/
  315. SetSecurity()
  316. {
  317.  if (MyRequest(ASK_REQ,(UBYTE *)"Security-Bit setzen?")){
  318.    LED(ON);
  319.    EditMode(PROG);
  320.    SetRow(SECURITY_ADR);
  321.    SDIn(1);
  322.    Clock();
  323.    STRImpuls();
  324.    InitGALer();
  325.    EnableOutput();
  326.    MyRequest(INFO_REQ,(UBYTE *)"Security-Bit wurde gesetzt.");
  327.   }
  328. }
  329.  
  330.  
  331.  
  332.  
  333.  
  334. /* GAL löschen */
  335. Loeschen()
  336. {
  337.  if (MyRequest(ASK_REQ,(UBYTE *)"GAL löschen")){
  338.    LED(ON);
  339.    EditMode(PROG);
  340.    SetRow(ERASE_ADR);
  341.    SDIn(1);
  342.    Clock();
  343.    STRImpuls();
  344.    InitGALer();
  345.    EnableOutput();
  346.    MyRequest(INFO_REQ,(UBYTE *)"GAL wurde gelöscht.");
  347.   }
  348. }
  349.  
  350.